package com.travel.controller;

import com.travel.common.Result;
import com.travel.domain.entity.Cultural;
import com.travel.service.CulturalService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.concurrent.TimeUnit;

@RestController
@RequestMapping("/cultural-creatives")
public class CulturalController {

    @Autowired
    private CulturalService culturalService;

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    private static final String CULTURAL_CACHE_KEY = "cultural:creatives";  // 缓存文创商品的键

    /**
     * 查询所有文创商品
     *
     * @return 文创商品列表
     */
    @GetMapping
    public Result<List<Cultural>> getAllCulturalCreatives() {
        // 尝试从缓存中获取文创商品列表
        List<Cultural> cachedCulturalList = (List<Cultural>) redisTemplate.opsForValue().get(CULTURAL_CACHE_KEY);

        if (cachedCulturalList != null) {
            // 如果缓存中有数据，直接返回缓存数据
            return Result.success(cachedCulturalList);
        }

        try {
            // 如果缓存中没有数据，则从数据库查询
            List<Cultural> culturalList = culturalService.list();

            // 将查询结果存入缓存，并设置过期时间（如 5 分钟）
            redisTemplate.opsForValue().set(CULTURAL_CACHE_KEY, culturalList, 5, TimeUnit.MINUTES);

            return Result.success(culturalList);
        } catch (Exception e) {
            // 捕获异常并记录错误
            return Result.error("获取文创商品列表失败");
        }
    }

    /**
     * 根据名称模糊查询文创产品
     *
     * @param name 文创产品名称（可选）
     * @return 查询结果
     */
    @GetMapping("/search/{name}")
    public Result<List<Cultural>> searchByName(@PathVariable(required = false) String name) {
        // 构建缓存键
        String cacheKey = "cultural:search:" + (name != null ? name : "all");

        // 尝试从缓存中获取搜索结果
        List<Cultural> cachedSearchResult = (List<Cultural>) redisTemplate.opsForValue().get(cacheKey);

        if (cachedSearchResult != null) {
            // 如果缓存中有数据，直接返回缓存数据
            return Result.success(cachedSearchResult);
        }

        try {
            // 如果缓存中没有数据，则进行数据库查询
            List<Cultural> result = culturalService.findByName(name);

            // 将查询结果存入缓存，并设置过期时间（如 5 分钟）
            redisTemplate.opsForValue().set(cacheKey, result, 5, TimeUnit.MINUTES);

            return Result.success(result);
        } catch (Exception e) {
            // 捕获异常并记录错误
            return Result.error("根据名称查询文创产品失败");
        }
    }
    /**
     * 根据ID查询文创商品
     *
     * @param id 商品ID
     * @return 查询结果
     */
    @GetMapping("getById/{id}")
    public Result<Cultural> getById(@PathVariable("id") Long id) {
        // 构建缓存键
        String cacheKey = "cultural:id:" + id;

        // 尝试从缓存中获取该商品
        Cultural cachedCultural = (Cultural) redisTemplate.opsForValue().get(cacheKey);

        if (cachedCultural != null) {
            // 如果缓存中有数据，直接返回缓存数据
            return Result.success(cachedCultural);
        }

        try {
            // 如果缓存中没有数据，使用 MyBatis-Plus 的 `getById` 方法查询商品
            Cultural cultural = culturalService.getById(id);

            if (cultural != null) {
                // 将查询结果存入缓存，并设置过期时间（如 5 分钟）
                redisTemplate.opsForValue().set(cacheKey, cultural, 5, TimeUnit.MINUTES);
                return Result.success(cultural);
            } else {
                return Result.error("未找到该商品");
            }
        } catch (Exception e) {
            // 捕获异常并记录错误
            return Result.error("根据ID查询文创商品失败");
        }
    }
}
